import axios from "axios"
import { Store } from "vuex"
import { handleProfile } from "./ProfileStore"
import { Resource } from "@/model/resource";
import { ref } from "vue";

/**
 * 用户登录 API 调用
 * @param email 用户邮箱
 * @param password 用户密码
 * @param store Vuex 存储
 * @returns 包含成功状态和消息的对象
 */
export const loginAPI = async (email: string, password: string, store: Store<any>)
    : Promise<{ R_loginAPI: boolean, message: string }> => {
    try {
        const response = await axios.post('/api/user/login', {
            email,
            password
        }, {
            headers: {
                'Content-Type': 'application/json'
            }
        });

        console.log("后端返回的数据：", response.data);

        if (response.data.code === 0) {
            handleProfile(store, response.data.data);
            alert('登录成功！');
            return { R_loginAPI: true, message: '登录成功' };
        } else {
            let message = '';
            switch (response.data.code) {
                case 1006:
                    message = '用户未注册';
                    break;
                case 1007:
                    message = '登录密码错误';
                    break;
                case 1005:
                    message = 'email格式错误或不支持该邮箱类型';
                    break;
                default:
                    break;
            }
            return { R_loginAPI: false, message };
        }
    } catch (error) {
        console.error('登录失败:', error);
        return { R_loginAPI: false, message: '网络异常，请稍后重试' };
    }
};



/**
 * 用户注册接口
 * 
 * @param email - 用户的邮箱
 * @param password - 用户的密码
 * @param username - 用户的用户名
 * @returns 成功或失败的信息对象
 */
export const registerAPI = async (email: string, password: string, username: string)
    : Promise<{ R_registerAPI: boolean, message: string }> => {

    try {
        // 发送注册请求
        console.log("发送注册请求: ", { username, email, password });
        const response = await axios.post('/api/user/register', {
            username,
            email,
            password
        }, {
            headers: {
                'Content-Type': 'application/json'
            }
        });

        // 打印后端返回的数据
        console.log("后端返回的数据：", response.data);

        if (response.data.code === 0) {
            alert('注册成功！');
            return { R_registerAPI: true, message: '注册成功' };
        } else {
            let message = '';
            switch (response.data.code) {
                case 1001:
                    message = '邮箱已被注册，请直接登陆';
                    break;
                case 1002:
                    message = 'password长度不符合要求';
                    break;
                case 1005:
                    message = 'email格式错误或不支持该邮箱类型';
                    break;
                default:
                    message = '未知错误';
                    break;
            }
            console.log("注册失败原因: ", message);
            return { R_registerAPI: false, message };
        }
    } catch (error) {
        // 注册失败，捕获异常
        console.error('注册失败:', error);
        return { R_registerAPI: false, message: '网络异常，请稍后重试' };
    }
}

/**
 * 自动登录接口
 * 
 * 如果用户之前登录过，后端将会自动返回用户信息
 * 
 * @param store - Vuex的store对象
 * @returns 无返回值
 */
export const autoLoginAPI = async (store: Store<any>) => {
    try {
        // 发送自动登录请求
        console.log("发送自动登录请求");
        const response = await axios.post('/api/user/autoLogin');

        // 打印后端返回的数据
        console.log("自动登录后端返回的数据：", response.data);

        if (response.data.code === 0) {
            // 如果自动登录成功，设置用户信息
            handleProfile(store, response.data.data);
        } else {
            console.log("自动登录失败：" + response.data.data);
        }
    } catch (error) {
        // 自动登录失败，捕获异常
        console.error('自动登录失败:', error);
    }
}

/**
 * 搜索资源 API
 * 
 * @param resourceName - 资源名称
 * @param resourceType - 资源类型
 * @param version - 版本号
 * @param providerId - 提供者ID
 * @returns 一个对象，包含一个success成员和一个resources成员
 *          success成员表示请求是否成功，resources成员是一个Resource对象的数组
 */
export const searchResourceAPI = async (
    resourceName: string,
    resourceType: string,
    providerId: number): Promise<{ R_searchResourceAPI: boolean, resources: Resource[] | null }> => {

    try {
        // 发送搜索资源请求
        const response = await axios.post('/api/resources/get', {
            resourceName,
            resourceType,
            providerId
        }, {
            headers: { 'Content-Type': 'multipart/form-data' }
        })
        console.log("后端返回的数据：", response.data)              //调试
        return { R_searchResourceAPI: true, resources: response.data.data }
    } catch (error) {
        // 搜索资源失败，捕获异常
        console.error('获取资源数据失败:', error)
        return { R_searchResourceAPI: false, resources: null }
    }
}


/**
 * 上传资源信息 API
 * 
 * @param resource - 资源对象
 * @returns 一个对象，包含一个success成员和一个id成员
 *          success成员表示请求是否成功，id成员是资源的id
 */
export const uploadRInformationAPI = async (resource: Resource)
    : Promise<{ R_uploadRInformationAPI: boolean, id: number }> => {

    try {
        // 发送资源信息上传请求
        const response = await axios.post('/api/resources/uploadResourceDatabase', resource, {
            headers: {
                'Content-Type': 'application/json'
            }
        })
        // 打印后端返回的数据
        console.log("后端返回的资源id:", response.data.data);

        if (response.data.code === 0) {
            // 如果上传成功，返回资源id
            return { R_uploadRInformationAPI: true, id: response.data.data }
        }
        return { R_uploadRInformationAPI: false, id: 0 }
    } catch (error) {
        // 上传失败，捕获异常
        console.error('上传失败:', error)
        return { R_uploadRInformationAPI: false, id: 0 }
    }
}


/**
 * 上传资源图片 API
 * 
 * @param id - 资源的 ID
 * @param images - 要上传的图片文件数组
 * @returns 一个对象，包含一个 success2 成员，表示请求是否成功
 */
export const uploadRImagesAPI = async (id: number, formDataImage: FormData)
    : Promise<{ R_uploadRImagesAPI: boolean }> => {

    try {
        // 发送图片上传请求
        const response = await axios.post('/api/resources/uploadResourceImage', formDataImage, {
            headers: {
                'Content-Type': 'multipart/form-data'
            }
        })

        // 检查响应代码，返回请求结果
        if (response.data.code === 0) {
            return { R_uploadRImagesAPI: true }
        }

    } catch (error) {
        // 捕获并记录上传失败的错误
        console.error('上传图片失败:', error)
    }
    return { R_uploadRImagesAPI: false }
}



/**
 * 上传资源块 API
 * 
 * @param id - 资源的 ID
 * @param file - 要上传的文件
 * @returns 一个对象，包含一个 success3 成员和一个 totalChunks 成员
 *          success3 成员表示请求是否成功，totalChunks 成员是资源的总块数
 */
export const uploadRChunksAPI = async (
    formDataChunk: FormData,
    currentChunkIndex: number)
    : Promise<{ R_uploadRChunksAPI: boolean }> => {

    try {
        const response = await axios.post('/api/resources/uploadResourceChunk', formDataChunk, {
            headers: { 'Content-Type': 'multipart/form-data' }
        });
        if (response.data.code === 0) {
            const result = response.data.data;
            if (result === currentChunkIndex + 1) {
                return { R_uploadRChunksAPI: true }
            } else if (result === -2) {
                return { R_uploadRChunksAPI: true }
            } else {
                return { R_uploadRChunksAPI: false }
            }
        } else {
            return { R_uploadRChunksAPI: false }
        }
    } catch (error) {
        console.error('上传块失败,错误信息：', error);
        return { R_uploadRChunksAPI: false }
    }
}


/**
 * 合并资源块 API
 * 
 * @param resourceId - 资源的 ID
 * @param resourceName - 资源的名称
 * @param totalChunks - 资源的总块数
 * @returns 一个对象，包含一个 success4 成员，表示请求是否成功
 */
export const jointRChunksAPI = async (resourceId: number, resourceName: string, totalChunks: number)
    : Promise<{ R_jointRChunksAPI: boolean }> => {
    console.log('上传完毕，开始合并');

    try {
        const response = await axios.post('/api/resources/jointResourceChunk', {
            resourceId,
            resourceName,
            totalChunks
        }, {
            headers: { 'Content-Type': 'multipart/form-data' }
        });
        if (response.data.code === 0) {
            return { R_jointRChunksAPI: true }
        }
    } catch (error) {
        console.error('块合并失败', error);
    }
    return { R_jointRChunksAPI: false };
}


export const clear = async (resourceId: number) => {
    console.log('上传失败，清理后端缓存');
    try {
        const response = await axios.post('/api/resources/uploadFail', {
            resourceId,
        }, {
            headers: { 'Content-Type': 'multipart/form-data' }
        });
        if (response.data.code === 0) {
            console.log('清理后端缓存成功');
        } else {
            console.log('清理后端缓存失败：' + response.data.data);
        }
    } catch (error) {
        console.error('清理后端缓存失败：', error);
    }
}

/**
 * 通过资源 ID 获取资源信息 API
 * 
 * @param resourceId - 资源的 ID
 * @returns 一个对象，包含一个 success1 成员和一个 resource 成员
 *          success1 表示请求是否成功，resource 是 Resource 对象|null
 */
export const getResourceInformationAPI = async (resourceId: number)
    : Promise<{ R_getResourceInformationAPI: boolean, resource: Resource | null }> => {
    // 一个 ref，用于存储资源信息
    const resource = ref<Resource>()

    try {
        // 通过 GET 请求获取资源信息
        const response = await axios.get(`/api/resources/getById/${resourceId}`)
        // 如果请求成功
        if (response.data.code === 0 && response.data.data) {
            // 将资源信息存储到 resource 中
            resource.value = response.data.data
            // 并返回一个包含 success1 和 resource 的对象
            return { R_getResourceInformationAPI: true, resource: resource.value as Resource }
        }
    } catch (error) {
        // 如果请求失败
        console.error('获取资源数据失败:', error)
        // 或 throw new Error("获取资源失败")
    }
    // 或 throw new Error("获取资源失败")
    return { R_getResourceInformationAPI: false, resource: null }
}



/**
 * 获取资源图片 API
 * 
 * @param resourceId - 资源的 ID
 * @returns 一个对象，包含一个 success2 成员和一个 images 成员
 *          success2 表示请求是否成功，images 是 base64 编码的图片数组|null
 */
export const getResourceImagesAPI = async (resourceId: number)
    : Promise<{ R_getResourceImagesAPI: boolean, images: string[] | null }> => {

    // 使用 ref 存储图片数组
    const images1 = ref<string[]>([])

    try {
        // 发起请求，获取资源图片
        const response = await axios.get(`/api/resources/getResourceImages/${resourceId}`)

        // 如果请求成功且有数据
        if (response.data.code === 0) {
            const data = response.data.data as string[]
            // 将 base64 编码的图片添加前缀转换为完整的图片 URL
            images1.value = data.map((base64: string) => `data:image/png;base64,${base64}`)
            return { R_getResourceImagesAPI: true, images: images1.value }
        }
    } catch (error) {
        // 捕获请求失败的异常
        console.error('获取图片数据失败:', error)
        return { R_getResourceImagesAPI: false, images: null }
    }
    // 如果请求不成功，返回失败状态
    return { R_getResourceImagesAPI: false, images: null }
}

export const updateRInformationAPI = async (resource: Resource)
    : Promise<{ R_updateRInformationAPI: boolean }> => {

    try {
        // 发送资源信息上传请求
        const response = await axios.post('/api/resources/updateResourceInformation', resource, {
            headers: {
                'Content-Type': 'application/json'
            }
        })
        // 打印后端返回的数据

        if (response.data.code === 0) {
            // 如果上传成功，返回资源id
            return { R_updateRInformationAPI: true }
        }
        if (response.data.code === 1200) {
            alert('非本人更改')
            return { R_updateRInformationAPI: false }
        }
        return { R_updateRInformationAPI: false }
    } catch (error) {
        // 上传失败，捕获异常
        console.error('更改失败:', error)
        return { R_updateRInformationAPI: false }
    }
}



export const deleteResourceAPI = async (id: number)
    : Promise<{ R_deleteResourceAPI: boolean }> => {
    try {
        const formData = new URLSearchParams()
        formData.append('id', id.toString())
        const response = await axios.post('/api/resources/deleteResource', formData, {
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded'
            }
        })
        if (response.data.code === 0) {
            return { R_deleteResourceAPI: true }
        }
        if (response.data.code === 1200) {
            alert('非本人更改')
            return { R_deleteResourceAPI: false }
        }
        if (response.data.code === 1201) {
            alert('资源不存在')
            return { R_deleteResourceAPI: false }
        }
    } catch (error) {
        console.error('删除失败:', error)
    }
    return { R_deleteResourceAPI: false }
}